"""作业：
1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
"""


def odd_index_elements(lst):
    return lst[0::2]
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = odd_index_elements(my_list)
print(result)
"""
2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
"""


def check_length(obj):
    return len(obj) > 5


string_obj = "Hello, World!"
print(check_length(string_obj))


# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
def count_chars(string):
    digits = 0
    letters = 0
    spaces = 0
    others = 0
    for char in string:
        if char.isdigit():
            digits += 1
        elif char.isalpha():
            letters += 1
        elif char.isspace():
            spaces += 1
        else:
            others += 1
    return digits, letters, spaces, others


string = "Hello, 123 World! 456"
result3 = count_chars(string)
print(result3)

# 4、写函数,接收两个数字参数,返回较大的那个数字
def max_num(num1, num2):
    return max(num1, num2)
result4 = max_num( 20, 30)
print(result4)
# 5、编写一个函数calcluate, 可以接收任意多个数,返回的是一个元组.
def calcluate(*args):
    return args
result5 = calcluate(1, 2, 3, 4, 5)
print(result5)
print(type(result5))
# 6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
def count_chars(string):
    upper_count = 0
    lower_count = 0
    for i in string:
        if i.isupper():
            upper_count += 1
        elif i.islower():
            lower_count += 1
    return upper_count, lower_count
result6 = count_chars("Hello, World!")
print(result6)

# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
import random
k = random.randint(1,100)
lst = [random.randint(1,100) for i in range(30)]
def reverse_random_list(lst, k):
    return lst[:k][::-1] + lst[k:][::-1]
print(reverse_random_list(lst,k))
# 8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
def calculate(x, n):
    result = 0
    for i in range(n):
        result += int(str(x) * (i + 1))  # 将x转换为字符串并重复i+1次
    return result
x = int(input("请输入一个整数x："))
n = int(input("请输入一个整数n："))
result8 = calculate(x, n)
print("结果为：", result8)
# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
def user_info(name, gender="男", age=None, address=None):
    info = f"姓名：{name}\n性别：{gender}\n"
    if age is not None:
        info += f"年龄：{age}\n"
    if address is not None:
        info += f"地址：{address}\n"
    return info
result9 = user_info("张三", "男", 18, "北京市朝阳区")
print(result9)
# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
def sum_numbers(*args):
    return sum(args)
result10 = sum_numbers(1, 2, 3, 4, 5)
print(result10)
# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
def add_to_args(*args, **kwargs):
    for obj in args:
        if isinstance(obj, str):
            kwargs["string"] = obj
        elif isinstance(obj, list):
            kwargs["list"] = obj
        elif isinstance(obj, tuple):
            kwargs["tuple"] = obj
        elif isinstance(obj, set):
            kwargs["set"] = obj
        elif isinstance(obj, dict):
            kwargs["dict"] = obj
    return kwargs
result11 = add_to_args("Hello", [1, 2, 3], (4, 5, 6), {7, 8, 9}, {"name": "张三", "age": 18})
print(result11)
# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
def add_underlines(lst):
    return "_".join(lst)
result12 = add_underlines(["Hello", "World"])
print(result12)
# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
def factorial(n):
    result = 1
    for i in range(1, n+1):
        result *= i
    return result
result13 = factorial(5)
print(result13)

# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
def poker():
    suits = ["红桃", "黑桃", "梅花", "方块"]
    ranks = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
    deck = []
    for suit in suits:
        for rank in ranks:
            deck.append((suit, rank))
    return deck
result14 = poker()
print(result14)
# 15、编写函数，求1+2+3+…N的和
def sum_n(n):
    return sum(range(1, n+1))
print(sum_n(10))
# 16、编写一个函数，求多个数中的最大值
def max_value(*args):
    return max(args)    # 使用内置函数max()求最大值
print(max_value( 2, 32, 49, 82, 27, 24, 27, 23))
# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
def select_letters(string):
    letters = ""
    for char in string:
        if char.isalpha():
            letters += char
    return letters
print(select_letters("Hello123World123456"))
# 18、写一个函数，求多个数的平均值
def sum_numbers(numbers):
    return sum(numbers) / len(numbers)
result18 = sum_numbers([1, 2, 3, 4, 5])
print(result18)
print(type(result18))
# 19、写一个自己的len函数，统计指定序列中元素的个数
def my_len(seq):
    count = 0
    for i in seq:
        count += 1
    return count
result19 = my_len("Hello,World!")
print(result19)

# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身

for i in range(100,1000):
        a = i // 100
        b = i % 100 // 10
        c = i % 10
        if a ** 3 + b ** 3 + c ** 3 == i:
            print(i)
# 22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# 数组中的每个元素值不允许超过 100，但是可以等于100，
# 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
def process_list(lst):
    if len(lst) > 100:
        lst = lst[:100]
    lst = list(set(lst))
    lst.sort(reverse=True)
    return lst
# 23、定义函数 getLength，打印用户传入的容器类型和数据长度
# 24、定义函数 generateNum( )
# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
# 27、写函数，检查传入字典的每一个value长度，如果大于2，
# 那么仅保留前两个长度的内容， 并将新内容返回给调用者

"""




 28、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
29、编写自定义函数，完成一个简单的减法运算函数
30、编写自定义函数，可以输出自己的名字即可。
31、编写自定义函数：剪刀石头布
游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。

 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了

当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数

1 代表剪刀 2 代表石头 3 代表布
32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
36、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
举例：
list1 = [100,200,300,454]
list2 = [454,789,125,46]
返回：[454]
 38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市"""
